home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1998 August: Tool Chest / Dev.CD Aug 98 TC.toast / Sample Code / OS Utilities / SetLED / SetLED.c < prev    next >
Encoding:
C/C++ Source or Header  |  1998-04-30  |  7.2 KB  |  219 lines  |  [TEXT/CWIE]
  1. /*
  2.     file:    SetLED.c
  3.             Sample program to demonstrate the use of the ADBOp call, including use
  4.             of the completion routine under 68K, CFM68K, and PPC.
  5.             
  6.             demonstrates a workaround for a bug with the CFM68K InterfaceLib glue
  7.             code such that a call to ADBOp under CFM68K results in a bus error.
  8.             This bug was identified with MacOS 8.1 running on different 68040 CPU's
  9.             
  10.     By: Rich Kubota    4/7/98
  11.         Macintosh Developer Support
  12.         
  13. */
  14.  
  15. #include <Types.h>
  16. #include <Events.h>
  17. #include <OSUtils.h>
  18. #include <DeskBus.h>
  19. #include <MixedMode.h>
  20.  
  21.  
  22. // keyboard ADB constants           
  23. #define kTalkCommand    8+4         
  24. #define kListenCommand  8           
  25. #define kLEDRegister    2       
  26.  
  27. #if TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  28. pascal long    GetA2( void )    ONEWORDINLINE(0x2E8A);
  29. #endif     //  TARGET_CPU_68K && !TARGET_RT_MAC_CFM
  30.  
  31. static long             gCompletionFlag;
  32. static ADBServiceRoutineUPP completionProc;                    
  33. static pascal void CompADBOp(void);
  34.  
  35. pascal OSErr MyADBOp(Ptr refCon, ADBServiceRoutineUPP compRout, 
  36.                             Ptr buffer, short commandNum);
  37.  
  38. // example completion routine for use with ADBOp
  39. pascal void CompADBOp(void)
  40. { 
  41. #if TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  42.     // Under, we can access global variables which is simpler
  43.     // than trying to write the glue code required so that 
  44.     // the completion routine is called with the registers
  45.     // set as per Inside Mac V-368
  46.     // set flag to indicate completion routine has completed
  47.     gCompletionFlag = 1;
  48. #else  // TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  49.  
  50.     // under 68K, but not CFM-68K, all of the arguments are passed
  51.     // in registers so we use inline functions to access those
  52.     // arguments.  In this sample, the optional data
  53.     // buffer argument is interest since we want to set a boolean flag to 
  54.     // indicate that the completion routine has been executed.  A similar
  55.     // macro as that for GetA2 can be written to access the command buffer
  56.     // pointer in register A0
  57.     long     *completionFlagPtr;
  58.  
  59.     // set flag to indicate completion routine has run; A2 points to the flag
  60.     completionFlagPtr = (long*)GetA2(); 
  61.     *completionFlagPtr = 1;
  62. #endif  // TARGET_CPU_PPC || TARGET_RT_MAC_CFM
  63. } /* end of CompADBOp */
  64.  
  65. #if TARGET_CPU_68K && TARGET_RT_MAC_CFM
  66. // The following code is implemented to fix a bug that exists with the 
  67. // 68K InterfaceLib glue code.  In order for the glue code to work, 
  68. // a pointer to an ADBOpBlock structure must be passed in register A0.
  69. // We define the global ADBOpBlock structure to support
  70. // the asynch ADBOp call
  71.  
  72. ADBOpBlock    gADBOpBlock;
  73. #endif     //  TARGET_CPU_68K && TARGET_RT_MAC_CFM
  74.  
  75. // Instead of making the ADBOp directly, call MyADBOp which makes 
  76. // the appropriate call depending on the target architecture.
  77. // For CFM68K, the ADBOpBlock structure is filled in and the
  78. // ADBGlue routine above is called. For regular 68K and PPC, the
  79. // ADBOp call is made straightaway.
  80.  
  81. pascal OSErr MyADBOp(
  82.      Ptr refCon,
  83.      ADBServiceRoutineUPP compRout,
  84.      Ptr buffer,
  85.      short commandNum)
  86. {
  87. #if TARGET_CPU_68K && TARGET_RT_MAC_CFM
  88.     ADBOpBlock    adbOpBlock;
  89.  
  90.     adbOpBlock.dataBuffPtr = buffer;
  91.     adbOpBlock.opServiceRtPtr = compRout;
  92.     adbOpBlock.opDataAreaPtr = refCon;
  93.     
  94.     // Important Note: In this sample, we declare the adbOpBlock
  95.     // structure as a stack variable.  Normally it is bad practice
  96.     // to use a stack parameter for any asynchronous call.
  97.     // ADBOp makes a copy of the contents of the structure so the
  98.     // structure does not need to exist for the life of the 
  99.     // asynchronous call.
  100.  
  101.     // Note that the refCon value is placed into the ADBOpBlock
  102.     // structure for completeness.
  103.     // This program sample assumes that a completion routine, under
  104.     // CFM, will access the refCon and the data buffer as globals
  105.     // to the process, since under CFM, this is possible.
  106.     // Otherwise, more glue code is required so that when CFM calls
  107.     // the completion routine, the 68K registers will be set as
  108.     // per Inside Mac V-368.
  109.     
  110.     return (OSErr) CallUniversalProc((UniversalProcPtr)NGetTrapAddress(0xA07C, 0),
  111.             kRegisterBased |
  112.             RESULT_SIZE(SIZE_CODE(sizeof(OSErr))) |
  113.             REGISTER_RESULT_LOCATION(kRegisterD0) |
  114.             REGISTER_ROUTINE_PARAMETER(1,
  115.                 kRegisterA0, SIZE_CODE(sizeof(&gADBOpBlock))) |
  116.             REGISTER_ROUTINE_PARAMETER(2,
  117.                 kRegisterD0, SIZE_CODE(sizeof(commandNum))),
  118.             &gADBOpBlock,
  119.             commandNum);
  120. #else  // TARGET_CPU_68K && TARGET_RT_MAC_CFM
  121.      return (ADBOp(refCon, compRout, buffer, commandNum));
  122. #endif  // TARGET_CPU_68K && TARGET_RT_MAC_CFM
  123. }
  124.  
  125. // set the leds to the given pattern }
  126. static void kb_SetMacNumLockLED( Boolean ledOn )
  127. {
  128.     OSErr               retCode;
  129.     ADBAddress          anADBadd;       // address of each device
  130.     Byte                regBuff[9];     // buffer for ADBOp commands
  131.     Byte                oldReg;
  132.     Byte                LEDPattern;
  133.     
  134.     if ( ledOn )
  135.         LEDPattern = 0x07;
  136.     else
  137.         LEDPattern = 0x00;
  138.     
  139.     // get an address for an ADB device - here we just talk to whatever keyboard
  140.     // is at ADB Address 2.  A more complete program might check the type of
  141.     // keyboard present to ensure that it has an LED present.
  142.     anADBadd = 2;
  143.     
  144.     regBuff[0] = (Byte)0; // initial data buffer length
  145.     regBuff[1] = 0;
  146.     regBuff[2] = 0;
  147.  
  148.     // initialize the completion flag so that we will know when the ADBOp call
  149.     // has completed.
  150.     gCompletionFlag = 0;
  151.     
  152.     retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  153.                                 kTalkCommand + kLEDRegister + 16 * anADBadd );
  154.     
  155.     if ( retCode != noErr )         // queue was full, try again
  156.     {
  157.         gCompletionFlag = 0;
  158.         retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  159.                                     kTalkCommand + kLEDRegister + 16 * anADBadd );
  160.         
  161.         if ( retCode != noErr )         // queue was still full, give up
  162.             return;
  163.     }
  164.     
  165.     // do nothing until completion routine has run
  166.     do
  167.     {
  168.     }
  169.     while ( ! gCompletionFlag );
  170.             
  171.     regBuff[0] = (Byte)2; // initial data buffer length
  172.     // extended keyboard has a word of data, LEDs are low 3 bits
  173.     oldReg = regBuff[2];
  174.     
  175.     // set the specified bits; note that a clear bit indicates a lit LED
  176.     // note that if LEDpattern is 7, then all three LED's will enable.
  177.     regBuff[2] = (oldReg & 255-7) | (7 - LEDPattern);
  178.  
  179.     // initialize the completion flag so that we will know when the ADBOp call
  180.     // has completed.
  181.     gCompletionFlag = 0;                        
  182.  
  183.     retCode = MyADBOp( (Ptr)&gCompletionFlag, completionProc, (Ptr)®Buff,
  184.                                 kListenCommand + kLEDRegister + 16 * anADBadd );
  185.  
  186.     if (retCode != noErr)
  187.         DebugStr("\p error on ADBOp for listen");
  188.     else
  189.     {
  190.             // do nothing until completion routine has run
  191.         do
  192.         {
  193.         }
  194.         while ( ! gCompletionFlag );
  195.     }
  196.  
  197. } /* end of kb_SetMacNumLockLED */
  198.  
  199.  
  200. void main (void)
  201. {
  202.     unsigned long    dummy;
  203.     short    i;
  204.  
  205.     completionProc = NewADBServiceRoutineProc( CompADBOp );
  206.  
  207.     i = 0;
  208.         // press the button to quit the test
  209.     while (!Button())
  210.     {
  211.         i++;
  212.         kb_SetMacNumLockLED(i % 2);
  213.         Delay(15, &dummy);
  214.     }
  215.  
  216.     if (completionProc != nil)
  217.         DisposeRoutineDescriptor( completionProc );
  218. }
  219.